home *** CD-ROM | disk | FTP | other *** search
/ MacHack 1997 / MacHack 1997.toast / Hacks / Hacks ’93 / The Regulator 1.4 / main.c next >
C/C++ Source or Header  |  1993-06-04  |  9KB  |  246 lines
  1. /*------------------------------------------------------------------------------
  2. #
  3. #   Apple Developer Technical Support
  4. #
  5. # SmallDaemon
  6. # A small faceless background-only application
  7. #
  8. #   main.c  -   C Source
  9. #
  10. #   Copyright © 1991 Apple Computer, Inc.
  11. #   All rights reserved.
  12. #
  13. #   Versions:   
  14. #               1.0               09/91       C.K. Haun <TR>
  15. #   
  16. #   Components:
  17. #                           main.c
  18. #                           AppleEvents.c
  19. #
  20. # This is a _very_ simple sample showing a do-nothing 
  21. # System 7.0 faceless background application.  
  22. # 
  23. # The main things to note are....
  24. # 1)  Look at the SIZE resource for the flag settings you'll
  25. #  need to let the Finder™ know that you only want to work
  26. #  in the background.
  27. # 2) Notice that you really do have your own heap and your own
  28. #  event loop.  You can do anything a foreground application
  29. #  can do, send AppleEvents, PPC stuff, anything else you'd
  30. #  like EXCEPT a graphic interface.
  31. # 3)  NOTE that no managers are started up.  You cannot start up
  32. #  Window, Menu, Dialogs, or anything else that 
  33. #  deals with the graphic front end.  Just leave them out.
  34. #  You _can_ start up QuickDraw, if you want to use some QuickDraw
  35. #  functions (like offscreen ports), but you CANNOT actually 
  36. #  do any screen drawing.
  37. #
  38. # Of course, a backgrounder can be launched from the Finder™ 
  39. # with a double-click.  However, if you'd like the backgrounder
  40. # to perform some useful service for your main application, driver,
  41. # DA, or whatever, you will want it running all the time.
  42. #  The BEST way to insure this is to install the backgrounder in the
  43. # StartUp Items folder in the system folder.  This will insure that
  44. # it is always launched, and it will also reduce memory fragmentation
  45. # since it will be installed at startup time.  You can search for it
  46. # when you need it with IPCListPorts (see the PPC toolbox documentation).
  47. # Optionally, you can use the LaunchApplication trap to launch it 
  48. # when you need it, and kill it when you're done.  But this could 
  49. # cause some multiFinder heap fragmentation.
  50. #
  51. # And remember, it's a backgrounder, you can't see it.  To kill it
  52. # use TaskIt or ProcDoggie.
  53. #
  54. # ---------------------------------------------------------------
  55. #   Use this sample as a starting point, and adapt its' routines to 
  56. #   meet the specific needs of your project.  
  57. #
  58. ------------------------------------------------------------------------------*/
  59.  
  60. /* This doesn't do much but wait for a quit event.  But, you can expand it */
  61. /* to suit whatever your needs are for a backgrounder.  */
  62. /* Be sure to look at the SIZE resource for this app to see how the */
  63. /* flags should be set for a background-only task */
  64. #include <memory.h>
  65. #include <appleevents.h>
  66. #include <events.h>
  67. #include <types.h>
  68. #include <gestaltequ.h>
  69. #include <SegLoad.h>
  70. #include "pb.h"
  71.  
  72. /* variables */
  73. Boolean gQuit = false;
  74. EventRecord gERecord;
  75. Boolean gHasAppleEvents;
  76. unsigned long gMySleep = 120;  /* long time, long time.  Change this if  */
  77. /* you'd like to do null processing. Just keep in mind that the */
  78. /* user does NOT know that you exist, and if you are eating */
  79. /* up a bunch of time the user will not know why his or her */
  80. /* machine is slowing down. */
  81.  
  82. /* structs */
  83. /* a little struct to install handlers from.  Makes it easier to plug in */
  84. /* new handlers */
  85. struct AEinstalls {
  86.     AEEventClass theClass;
  87.     AEEventID theEvent;
  88.     EventHandlerProcPtr theProc;
  89. };
  90. typedef struct AEinstalls AEinstalls;
  91.  
  92. /* prototypes for this file */
  93. pascal OSErr AEOpenHandler(AppleEvent *messagein, AppleEvent *reply, long refIn);
  94. pascal OSErr AEOpenDocHandler(AppleEvent *messagein, AppleEvent *reply, long refIn);
  95. pascal OSErr AEPrintHandler(AppleEvent *messagein, AppleEvent *reply, long refIn);
  96. pascal OSErr AEQuitHandler(AppleEvent *messagein, AppleEvent *reply, long refIn);
  97. void DoHighLevel(EventRecord *AERecord);
  98. void InitAEStuff(void);
  99.  
  100. main()
  101. {
  102.     /* We are NOT initializing any managers.  We're in the background, with no */
  103.     /* face, we can't use windows or dialogs or menus.  If you need to talk to the */
  104.     /* user you can post a notification, or launch an application to communicate */
  105.     /* Passing an AppleEvent in the launchapplication trap could do the */
  106.     /* communication for you. */
  107. #ifdef MPW
  108.     extern void _DataInit();
  109.     
  110.     UnloadSeg((Ptr)_DataInit);
  111. #endif
  112.     InitGraf((Ptr) &qd.thePort);
  113.     /* Routine to install Apple event handlers */
  114.     InitAEStuff();
  115.     
  116.     InitPrefs();        // opens the prefs resource file, reads in the user's times
  117.     
  118.     InitPortableStuff();
  119.  
  120.     /* no nothing but high level events */
  121.     while (gQuit == false) {
  122.         WaitNextEvent(highLevelEventMask, &gERecord, gMySleep, 0);
  123.         CheckForMains();
  124.         switch (gERecord.what) {                    
  125.             case kHighLevelEvent:
  126.             DoHighLevel(&gERecord);
  127.             break;
  128.         }
  129.     }
  130. }
  131.  
  132. /* Here are the AppleEvent handlers for this background-only task. */
  133. /* Since this is a real live application, it can accept and send any */
  134. /* Apple Events you want to send or receive.  */
  135. /* In this case, the only ones that make any sense in this app are */
  136. /* 'oapp' and 'quit' */
  137.  
  138.  
  139. /* InitAEStuff checks for the availability of the AppleEvent Manager and */
  140. /* installs our event handlers. */
  141. /* if the AEM isn't around, we bail. */
  142. void InitAEStuff(void)
  143. {
  144.     static AEinstalls HandlersToInstall[] =  {
  145.          {
  146.             kCoreEventClass, kAEOpenApplication, AEOpenHandler
  147.         },  {
  148.             kCoreEventClass, kAEOpenDocuments, AEOpenDocHandler
  149.         },  {
  150.             kCoreEventClass, kAEQuitApplication, AEQuitHandler
  151.         },  {
  152.             kCoreEventClass, kAEPrintDocuments, AEPrintHandler
  153.         }, 
  154.         /* The above are the four required AppleEvents. */
  155.     };
  156.     
  157.     OSErr aevtErr = noErr;
  158.     long aLong = 0;
  159.     Boolean gHasAppleEvents = false;
  160.     /* Check this machine for AppleEvents.  If they are not here (ie not 7.0)
  161.     *   then we exit */
  162.     gHasAppleEvents = (Gestalt(gestaltAppleEventsAttr, &aLong) == noErr);
  163.     /* The following series of calls installs all our AppleEvent Handlers.
  164.     *   These handlers are added to the application event handler list that 
  165.     *   the AppleEvent manager maintains.  So, whenever an AppleEvent happens
  166.     *   and we call AEProcessEvent, the AppleEvent manager will check our
  167.     *   list of handlers and dispatch to it if there is one.
  168.     */
  169.     if (gHasAppleEvents) {
  170.         register qq;
  171.         for (qq = 0; qq < ((sizeof(HandlersToInstall) / sizeof(AEinstalls))); qq++) {
  172.             aevtErr = AEInstallEventHandler(HandlersToInstall[qq].theClass, HandlersToInstall[qq].theEvent,
  173.                                             HandlersToInstall[qq].theProc, 0, false);
  174.             if (aevtErr) {
  175.                 /* Of course, you can't tell the user why you died directly, since you have no face.  */
  176.                 /* But, you can post a notification from here to let them know. */
  177.                 ExitToShell();                              /* just fail, baby */
  178.             }
  179.         }
  180.     } else {
  181.         ExitToShell();
  182.     }
  183. }
  184.  
  185. /* end InitAEStuff */
  186.  
  187. void DoHighLevel(EventRecord *AERecord)
  188. {
  189.     /* I'm not doing any error handling here because there's not a lot */
  190.     /* I can do, just pass the errors back. */
  191.     AEProcessAppleEvent(AERecord);
  192.     
  193. }
  194.  
  195. /* end DoHighLevel */
  196.  
  197.  
  198. /* This is the standard Open Application event.   */
  199. pascal OSErr AEOpenHandler(AppleEvent *messagein, AppleEvent *reply, long refIn)
  200. {
  201. #pragma unused (messagein,reply,refIn)
  202.     /* we of course don't do anything here, since we're background only */
  203.     /* But this was a normal launch, so return noErr */
  204.     return(noErr);
  205. }
  206.  
  207. /* end AEOpenHandler */
  208.  
  209. /* Open Doc, opens our documents. */
  210. /* In this case, of course, you are in the background so you should return an error */
  211. /* here since you're not opening a document. */
  212. /* Of course, you _might_ want to open a doc, but you will probably */
  213. /* confuse the user if you do, since they will see no action as the */
  214. /*  result of their clicking on a document icon. */
  215. pascal OSErr AEOpenDocHandler(AppleEvent *messagein, AppleEvent *reply, long refIn)
  216. {
  217. #pragma unused (reply, refIn,messagein)
  218.     /* we of course don't do anything here, so tell the sender that we  */
  219.     /* didn't handle the event */
  220.     return(errAEEventNotHandled);
  221. }
  222.  
  223. /* same logic for printing */
  224. pascal OSErr AEPrintHandler(AppleEvent *messagein, AppleEvent *reply, long refIn)
  225. {
  226. #pragma unused (reply,refIn,messagein)
  227.     /* we of course don't do anything here */
  228.     return(errAEEventNotHandled);
  229. }
  230.  
  231. /* Standard Quit event handler, to handle a Quit event from the Finder, for example.  */
  232. /* ••••• DO NOT CALL EXITTOSHELL HERE ••••• or you will never have a happy life.  */
  233. pascal OSErr AEQuitHandler(AppleEvent *messagein, AppleEvent *reply, long refIn)
  234. {
  235. #pragma unused (messagein,refIn,reply)
  236.     extern Boolean Quit;
  237.     /*  This does _NOT_ quit, you */
  238.     /* should NEVER quit from an AppleEvent handler.  Calling */
  239.     /* ExitToShell here would blow up the Finder™ */
  240.     SetRest();
  241.     SetSysSleep(gSysSleep);
  242.     SetHDSleep(gHDSleep);
  243.     gQuit = true;
  244.     return(noErr);
  245. }
  246.